/*
** Lua binding: Ice
** Generated automatically by tolua++-1.0.92.
*/

/****************************************************************************
 Copyright (c) 2011 cocos2d-x.org

 http://www.cocos2d-x.org

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ****************************************************************************/




#include "CCLuaEngine.h"
#include "tolua_fix.h"
#include "Ice/Ice.h"
#include "LuaIce.h"
#include "CCIceSession.h"
#include "IceLua_Proxy.h"
#include "IceLuaSupport.h"
#include "tolua_framework.h"
using namespace cocos2d;
using namespace std;

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_std__vector_int_ (lua_State* tolua_S)
{
 std::vector<int>* self = (std::vector<int>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_Ice__Byte_ (lua_State* tolua_S)
{
 std::vector<Ice::Byte>* self = (std::vector<Ice::Byte>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_char_ (lua_State* tolua_S)
{
 std::vector<char>* self = (std::vector<char>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_vector_string_ (lua_State* tolua_S)
{
 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_Ice__ObjectPrx (lua_State* tolua_S)
{
 Ice::ObjectPrx* self = (Ice::ObjectPrx*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_Ice__Long (lua_State* tolua_S)
{
 Ice::Long* self = (Ice::Long*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_float_ (lua_State* tolua_S)
{
 std::vector<float>* self = (std::vector<float>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_vector_Ice__Long_ (lua_State* tolua_S)
{
 vector<Ice::Long>* self = (vector<Ice::Long>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_OutputStreamWrapper (lua_State* tolua_S)
{
 OutputStreamWrapper* self = (OutputStreamWrapper*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_std__string_ (lua_State* tolua_S)
{
 std::vector<std::string>* self = (std::vector<std::string>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_double_ (lua_State* tolua_S)
{
 std::vector<double>* self = (std::vector<double>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_short_ (lua_State* tolua_S)
{
 std::vector<short>* self = (std::vector<short>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_vector_Ice__Byte_ (lua_State* tolua_S)
{
 vector<Ice::Byte>* self = (vector<Ice::Byte>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CCIceSession (lua_State* tolua_S)
{
 CCIceSession* self = (CCIceSession*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_vector_int_ (lua_State* tolua_S)
{
 vector<int>* self = (vector<int>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_bool_ (lua_State* tolua_S)
{
 std::vector<bool>* self = (std::vector<bool>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_ConnectionInfo (lua_State* tolua_S)
{
 ConnectionInfo* self = (ConnectionInfo*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_long_ (lua_State* tolua_S)
{
 std::vector<long>* self = (std::vector<long>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_Ice__CommunicatorPtr (lua_State* tolua_S)
{
 Ice::CommunicatorPtr* self = (Ice::CommunicatorPtr*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"std::vector<int>");
 tolua_usertype(tolua_S,"vector<Ice::Short>");
 tolua_usertype(tolua_S,"Ice::ObjectPrx");
 tolua_usertype(tolua_S,"LuaException");
 tolua_usertype(tolua_S,"std::vector<bool>");
 tolua_usertype(tolua_S,"std::vector<std::string>");
 tolua_usertype(tolua_S,"LuaDelegate");
 tolua_usertype(tolua_S,"Ice::Exception");
 
 tolua_usertype(tolua_S,"ConnectionInfo");
 tolua_usertype(tolua_S,"std::vector<long>");
 tolua_usertype(tolua_S,"std::vector<double>");
 tolua_usertype(tolua_S,"std::vector<Ice::Byte>");
 tolua_usertype(tolua_S,"std::vector<char>");
 tolua_usertype(tolua_S,"map<int,int>");
 tolua_usertype(tolua_S,"vector<string>");
 tolua_usertype(tolua_S,"vector<Ice::Byte>");
 tolua_usertype(tolua_S,"std::vector<float>");
 tolua_usertype(tolua_S,"vector<std::string>");
 tolua_usertype(tolua_S,"vector<Ice::Double>");
 tolua_usertype(tolua_S,"vector<Ice::Long>");
 tolua_usertype(tolua_S,"std::vector<short>");
 tolua_usertype(tolua_S,"vector<Ice::Float>");
 tolua_usertype(tolua_S,"CCIceSession");
 tolua_usertype(tolua_S,"vector<bool>");
 tolua_usertype(tolua_S,"std::exception");
 tolua_usertype(tolua_S,"OutputStreamWrapper");
 tolua_usertype(tolua_S,"InputStreamWrapper");
 tolua_usertype(tolua_S,"vector<int>");
 tolua_usertype(tolua_S,"Glacier2::SessionPrx");
 tolua_usertype(tolua_S,"Ice::Long");
 tolua_usertype(tolua_S,"Ice::OutputStream");
 tolua_usertype(tolua_S,"Ice::CommunicatorPtr");
}

/* method: clear of class  vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_int__clear00
static int tolua_Ice_vector_int__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<int>* self = (vector<int>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_int__size00
static int tolua_Ice_vector_int__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const vector<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const vector<int>* self = (const vector<int>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_int___geti00
static int tolua_Ice_vector_int___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const vector<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const vector<int>* self = (const vector<int>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   const int tolua_ret = (const int)  self->operator[](index);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_int___seti00
static int tolua_Ice_vector_int___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<int>* self = (vector<int>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  int tolua_value = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_int___geti01
static int tolua_Ice_vector_int___geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  vector<int>* self = (vector<int>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   int tolua_ret = (int)  self->operator[](index);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_Ice_vector_int___geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_int__push_back00
static int tolua_Ice_vector_int__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<int>* self = (vector<int>*)  tolua_tousertype(tolua_S,1,0);
  int val = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_int__new00
static int tolua_Ice_vector_int__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"vector<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   vector<int>* tolua_ret = (vector<int>*)  Mtolua_new((vector<int>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<int>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_int__new00_local
static int tolua_Ice_vector_int__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"vector<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   vector<int>* tolua_ret = (vector<int>*)  Mtolua_new((vector<int>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_int__delete00
static int tolua_Ice_vector_int__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<int>* self = (vector<int>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  vector<string> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_string__clear00
static int tolua_Ice_vector_string__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<string>* self = (vector<string>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  vector<string> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_string__size00
static int tolua_Ice_vector_string__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const vector<string>* self = (const vector<string>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  vector<string> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_string___geti00
static int tolua_Ice_vector_string___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const vector<string>* self = (const vector<string>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   const string tolua_ret = (const string)  self->operator[](index);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  vector<string> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_string___seti00
static int tolua_Ice_vector_string___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<string>* self = (vector<string>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  string tolua_value = ((string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  vector<string> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_string___geti01
static int tolua_Ice_vector_string___geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  vector<string>* self = (vector<string>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   string tolua_ret = (string)  self->operator[](index);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_Ice_vector_string___geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  vector<string> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_string__push_back00
static int tolua_Ice_vector_string__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<string>* self = (vector<string>*)  tolua_tousertype(tolua_S,1,0);
  string val = ((string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  vector<string> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_string__new00
static int tolua_Ice_vector_string__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"vector<string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   vector<string>* tolua_ret = (vector<string>*)  Mtolua_new((vector<string>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<string>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  vector<string> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_string__new00_local
static int tolua_Ice_vector_string__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"vector<string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   vector<string>* tolua_ret = (vector<string>*)  Mtolua_new((vector<string>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  vector<string> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_string__delete00
static int tolua_Ice_vector_string__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<string>* self = (vector<string>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  vector<Ice::Long> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Long__clear00
static int tolua_Ice_vector_Ice__Long__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<Ice::Long>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<Ice::Long>* self = (vector<Ice::Long>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  vector<Ice::Long> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Long__size00
static int tolua_Ice_vector_Ice__Long__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const vector<Ice::Long>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const vector<Ice::Long>* self = (const vector<Ice::Long>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  vector<Ice::Long> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Long___geti00
static int tolua_Ice_vector_Ice__Long___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const vector<Ice::Long>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const vector<Ice::Long>* self = (const vector<Ice::Long>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   const Ice::Long tolua_ret = (const Ice::Long)  self->operator[](index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ice::Long)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"const Ice::Long");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const Ice::Long));
     tolua_pushusertype(tolua_S,tolua_obj,"const Ice::Long");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  vector<Ice::Long> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Long___seti00
static int tolua_Ice_vector_Ice__Long___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<Ice::Long>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !toluafix_is_longlong(tolua_S,3,"Ice::Long",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<Ice::Long>* self = (vector<Ice::Long>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  Ice::Long tolua_value = (toluafix_to_longlong(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  vector<Ice::Long> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Long___geti01
static int tolua_Ice_vector_Ice__Long___geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<Ice::Long>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  vector<Ice::Long>* self = (vector<Ice::Long>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   Ice::Long tolua_ret = (Ice::Long)  self->operator[](index);
   toluafix_push_longlong(tolua_S, &tolua_ret,"Ice::Long");
  }
 }
 return 1;
tolua_lerror:
 return tolua_Ice_vector_Ice__Long___geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  vector<Ice::Long> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Long__push_back00
static int tolua_Ice_vector_Ice__Long__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<Ice::Long>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !toluafix_is_longlong(tolua_S,2,"Ice::Long",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<Ice::Long>* self = (vector<Ice::Long>*)  tolua_tousertype(tolua_S,1,0);
  Ice::Long val = (toluafix_to_longlong(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  vector<Ice::Long> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Long__new00
static int tolua_Ice_vector_Ice__Long__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"vector<Ice::Long>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   vector<Ice::Long>* tolua_ret = (vector<Ice::Long>*)  Mtolua_new((vector<Ice::Long>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<Ice::Long>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  vector<Ice::Long> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Long__new00_local
static int tolua_Ice_vector_Ice__Long__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"vector<Ice::Long>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   vector<Ice::Long>* tolua_ret = (vector<Ice::Long>*)  Mtolua_new((vector<Ice::Long>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<Ice::Long>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  vector<Ice::Long> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Long__delete00
static int tolua_Ice_vector_Ice__Long__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<Ice::Long>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<Ice::Long>* self = (vector<Ice::Long>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Byte__clear00
static int tolua_Ice_vector_Ice__Byte__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<Ice::Byte>* self = (vector<Ice::Byte>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Byte__size00
static int tolua_Ice_vector_Ice__Byte__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const vector<Ice::Byte>* self = (const vector<Ice::Byte>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Byte___geti00
static int tolua_Ice_vector_Ice__Byte___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const vector<Ice::Byte>* self = (const vector<Ice::Byte>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   unsigned const char tolua_ret = ( unsigned const char)  self->operator[](index);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Byte___seti00
static int tolua_Ice_vector_Ice__Byte___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<Ice::Byte>* self = (vector<Ice::Byte>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  unsigned char tolua_value = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Byte___geti01
static int tolua_Ice_vector_Ice__Byte___geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  vector<Ice::Byte>* self = (vector<Ice::Byte>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->operator[](index);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_Ice_vector_Ice__Byte___geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Byte__push_back00
static int tolua_Ice_vector_Ice__Byte__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<Ice::Byte>* self = (vector<Ice::Byte>*)  tolua_tousertype(tolua_S,1,0);
  unsigned char val = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Byte__new00
static int tolua_Ice_vector_Ice__Byte__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   vector<Ice::Byte>* tolua_ret = (vector<Ice::Byte>*)  Mtolua_new((vector<Ice::Byte>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<Ice::Byte>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Byte__new00_local
static int tolua_Ice_vector_Ice__Byte__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   vector<Ice::Byte>* tolua_ret = (vector<Ice::Byte>*)  Mtolua_new((vector<Ice::Byte>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<Ice::Byte>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_vector_Ice__Byte__delete00
static int tolua_Ice_vector_Ice__Byte__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  vector<Ice::Byte>* self = (vector<Ice::Byte>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  map<int,int> */
#ifndef TOLUA_DISABLE_tolua_Ice_map_int_int__size00
static int tolua_Ice_map_int_int__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const map<int,int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const map<int,int>* self = (const map<int,int>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   unsigned tolua_ret = (unsigned)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  map<int,int> */
#ifndef TOLUA_DISABLE_tolua_Ice_map_int_int___seti00
static int tolua_Ice_map_int_int___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"map<int,int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  map<int,int>* self = (map<int,int>*)  tolua_tousertype(tolua_S,1,0);
  int tolua_var_2 = ((int)  tolua_tonumber(tolua_S,2,0));
  int tolua_value = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](tolua_var_2) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  map<int,int> */
#ifndef TOLUA_DISABLE_tolua_Ice_map_int_int___geti00
static int tolua_Ice_map_int_int___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"map<int,int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  map<int,int>* self = (map<int,int>*)  tolua_tousertype(tolua_S,1,0);
  int tolua_var_1 = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   int tolua_ret = (int)  self->operator[](tolua_var_1);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addScriptHandler of class  LuaDelegate */
#ifndef TOLUA_DISABLE_tolua_Ice_LuaDelegate_addScriptHandler00
static int tolua_Ice_LuaDelegate_addScriptHandler00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaDelegate",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !toluafix_isfunction(tolua_S,2,"LUA_FUNCTION",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaDelegate* self = (LuaDelegate*)  tolua_tousertype(tolua_S,1,0);
  LUA_FUNCTION handler = (  toluafix_ref_function(tolua_S,2,0));

#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addScriptHandler'", NULL);
#endif
  {
   int tolua_ret = (int)  self->addScriptHandler(handler);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addScriptHandler'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeScriptHandler of class  LuaDelegate */
#ifndef TOLUA_DISABLE_tolua_Ice_LuaDelegate_removeScriptHandler00
static int tolua_Ice_LuaDelegate_removeScriptHandler00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaDelegate",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !toluafix_isfunction(tolua_S,2,"LUA_FUNCTION",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaDelegate* self = (LuaDelegate*)  tolua_tousertype(tolua_S,1,0);
  LUA_FUNCTION handler = (  toluafix_ref_function(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeScriptHandler'", NULL);
#endif
  {
   self->removeScriptHandler(handler);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeScriptHandler'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearScriptHandler of class  LuaDelegate */
#ifndef TOLUA_DISABLE_tolua_Ice_LuaDelegate_clearScriptHandler00
static int tolua_Ice_LuaDelegate_clearScriptHandler00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaDelegate",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaDelegate* self = (LuaDelegate*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearScriptHandler'", NULL);
#endif
  {
   self->clearScriptHandler();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearScriptHandler'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  ConnectionInfo */
#ifndef TOLUA_DISABLE_tolua_Ice_ConnectionInfo_new00
static int tolua_Ice_ConnectionInfo_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"ConnectionInfo",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  string ip = ((string)  tolua_tocppstring(tolua_S,2,0));
  int port = ((int)  tolua_tonumber(tolua_S,3,0));
  string account = ((string)  tolua_tocppstring(tolua_S,4,0));
  string password = ((string)  tolua_tocppstring(tolua_S,5,0));
  int timeout = ((int)  tolua_tonumber(tolua_S,6,0));
  string routerName = ((string)  tolua_tocppstring(tolua_S,7,0));
  {
   ConnectionInfo* tolua_ret = (ConnectionInfo*)  Mtolua_new((ConnectionInfo)(ip,port,account,password,timeout,routerName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"ConnectionInfo");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  ConnectionInfo */
#ifndef TOLUA_DISABLE_tolua_Ice_ConnectionInfo_new00_local
static int tolua_Ice_ConnectionInfo_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"ConnectionInfo",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  string ip = ((string)  tolua_tocppstring(tolua_S,2,0));
  int port = ((int)  tolua_tonumber(tolua_S,3,0));
  string account = ((string)  tolua_tocppstring(tolua_S,4,0));
  string password = ((string)  tolua_tocppstring(tolua_S,5,0));
  int timeout = ((int)  tolua_tonumber(tolua_S,6,0));
  string routerName = ((string)  tolua_tocppstring(tolua_S,7,0));
  {
   ConnectionInfo* tolua_ret = (ConnectionInfo*)  Mtolua_new((ConnectionInfo)(ip,port,account,password,timeout,routerName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"ConnectionInfo");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  ConnectionInfo */
#ifndef TOLUA_DISABLE_tolua_Ice_ConnectionInfo_new01
static int tolua_Ice_ConnectionInfo_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"ConnectionInfo",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  {
   ConnectionInfo* tolua_ret = (ConnectionInfo*)  Mtolua_new((ConnectionInfo)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"ConnectionInfo");
  }
 }
 return 1;
tolua_lerror:
 return tolua_Ice_ConnectionInfo_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  ConnectionInfo */
#ifndef TOLUA_DISABLE_tolua_Ice_ConnectionInfo_new01_local
static int tolua_Ice_ConnectionInfo_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"ConnectionInfo",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  {
   ConnectionInfo* tolua_ret = (ConnectionInfo*)  Mtolua_new((ConnectionInfo)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"ConnectionInfo");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_Ice_ConnectionInfo_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setProperty of class  ConnectionInfo */
#ifndef TOLUA_DISABLE_tolua_Ice_ConnectionInfo_setProperty00
static int tolua_Ice_ConnectionInfo_setProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"ConnectionInfo",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  ConnectionInfo* self = (ConnectionInfo*)  tolua_tousertype(tolua_S,1,0);
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string value = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setProperty'", NULL);
#endif
  {
   self->setProperty(key,value);
   tolua_pushcppstring(tolua_S,(const char*)key);
   tolua_pushcppstring(tolua_S,(const char*)value);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: account of class  ConnectionInfo */
#ifndef TOLUA_DISABLE_tolua_get_ConnectionInfo_account
static int tolua_get_ConnectionInfo_account(lua_State* tolua_S)
{
  ConnectionInfo* self = (ConnectionInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'account'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->account);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: account of class  ConnectionInfo */
#ifndef TOLUA_DISABLE_tolua_set_ConnectionInfo_account
static int tolua_set_ConnectionInfo_account(lua_State* tolua_S)
{
  ConnectionInfo* self = (ConnectionInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'account'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->account = ((string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: password of class  ConnectionInfo */
#ifndef TOLUA_DISABLE_tolua_get_ConnectionInfo_password
static int tolua_get_ConnectionInfo_password(lua_State* tolua_S)
{
  ConnectionInfo* self = (ConnectionInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'password'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->password);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: password of class  ConnectionInfo */
#ifndef TOLUA_DISABLE_tolua_set_ConnectionInfo_password
static int tolua_set_ConnectionInfo_password(lua_State* tolua_S)
{
  ConnectionInfo* self = (ConnectionInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'password'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->password = ((string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_Ice_CCIceSession_delete00
static int tolua_Ice_CCIceSession_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCIceSession",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCIceSession* self = (CCIceSession*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: connect of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_Ice_CCIceSession_connect00
static int tolua_Ice_CCIceSession_connect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCIceSession",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ConnectionInfo",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCIceSession* self = (CCIceSession*)  tolua_tousertype(tolua_S,1,0);
  const ConnectionInfo* tolua_var_3 = ((const ConnectionInfo*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'connect'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->connect(*tolua_var_3);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'connect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: disconnect of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_Ice_CCIceSession_disconnect00
static int tolua_Ice_CCIceSession_disconnect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCIceSession",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCIceSession* self = (CCIceSession*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'disconnect'", NULL);
#endif
  {
   self->disconnect();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'disconnect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: invoke of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_Ice_CCIceSession_invoke00
static int tolua_Ice_CCIceSession_invoke00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCIceSession",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"std::vector<Ice::Byte>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !toluafix_isfunction(tolua_S,5,"LUA_FUNCTION",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCIceSession* self = (CCIceSession*)  tolua_tousertype(tolua_S,1,0);
  std::string facet = ((std::string)  tolua_tocppstring(tolua_S,2,0));
  std::string operation = ((std::string)  tolua_tocppstring(tolua_S,3,0));
  std::vector<Ice::Byte>* params = ((std::vector<Ice::Byte>*)  tolua_tousertype(tolua_S,4,0));
  LUA_FUNCTION handler = (  toluafix_ref_function(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'invoke'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->invoke(facet,operation,params,handler);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'invoke'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addCallback of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_Ice_CCIceSession_addCallback00
static int tolua_Ice_CCIceSession_addCallback00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCIceSession",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !toluafix_isfunction(tolua_S,3,"LUA_FUNCTION",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCIceSession* self = (CCIceSession*)  tolua_tousertype(tolua_S,1,0);
  std::string name = ((std::string)  tolua_tocppstring(tolua_S,2,0));
  LUA_FUNCTION luaFunc = (  toluafix_ref_function(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addCallback'", NULL);
#endif
  {
   Ice::ObjectPrx tolua_ret = (Ice::ObjectPrx)  self->addCallback(name,luaFunc);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ice::ObjectPrx)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ice::ObjectPrx");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ice::ObjectPrx));
     tolua_pushusertype(tolua_S,tolua_obj,"Ice::ObjectPrx");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addCallback'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createOutputStream of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_Ice_CCIceSession_createOutputStream00
static int tolua_Ice_CCIceSession_createOutputStream00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCIceSession",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCIceSession* self = (CCIceSession*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createOutputStream'", NULL);
#endif
  {
   Ice::OutputStream* tolua_ret = (Ice::OutputStream*)  self->createOutputStream();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ice::OutputStream");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createOutputStream'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: disconnect of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_Ice_CCIceSession_disconnect01
static int tolua_Ice_CCIceSession_disconnect01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCIceSession",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CCIceSession* self = (CCIceSession*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'disconnect'", NULL);
#endif
  {
   self->disconnect();
  }
 }
 return 0;
tolua_lerror:
 return tolua_Ice_CCIceSession_disconnect00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_Ice_CCIceSession_create00
static int tolua_Ice_CCIceSession_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CCIceSession",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CCIceSession* tolua_ret = (CCIceSession*)  CCIceSession::create();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CCIceSession");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: eventConnected of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_get_CCIceSession_eventConnected
static int tolua_get_CCIceSession_eventConnected(lua_State* tolua_S)
{
  CCIceSession* self = (CCIceSession*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'eventConnected'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->eventConnected,"LuaDelegate");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: eventConnectFailed of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_get_CCIceSession_eventConnectFailed
static int tolua_get_CCIceSession_eventConnectFailed(lua_State* tolua_S)
{
  CCIceSession* self = (CCIceSession*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'eventConnectFailed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->eventConnectFailed,"LuaDelegate");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: eventDisconnected of class  CCIceSession */
#ifndef TOLUA_DISABLE_tolua_get_CCIceSession_eventDisconnected
static int tolua_get_CCIceSession_eventDisconnected(lua_State* tolua_S)
{
  CCIceSession* self = (CCIceSession*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'eventDisconnected'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->eventDisconnected,"LuaDelegate");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: what of class  Ice::Exception */
#ifndef TOLUA_DISABLE_tolua_Ice_Ice_Exception_what00
static int tolua_Ice_Ice_Exception_what00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ice::Exception",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ice::Exception* self = (Ice::Exception*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'what'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->what();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'what'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ice_name of class  Ice::Exception */
#ifndef TOLUA_DISABLE_tolua_Ice_Ice_Exception_ice_name00
static int tolua_Ice_Ice_Exception_ice_name00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ice::Exception",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ice::Exception* self = (Ice::Exception*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ice_name'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->ice_name();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ice_name'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Ice::ObjectPrx */
#ifndef TOLUA_DISABLE_tolua_Ice_Ice_ObjectPrx_new00
static int tolua_Ice_Ice_ObjectPrx_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ice::ObjectPrx",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ice::ObjectPrx",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ice::ObjectPrx* object = ((const Ice::ObjectPrx*)  tolua_tousertype(tolua_S,2,0));
  {
   Ice::ObjectPrx* tolua_ret = (Ice::ObjectPrx*)  Mtolua_new((Ice::ObjectPrx)(*object));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ice::ObjectPrx");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Ice::ObjectPrx */
#ifndef TOLUA_DISABLE_tolua_Ice_Ice_ObjectPrx_new00_local
static int tolua_Ice_Ice_ObjectPrx_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ice::ObjectPrx",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ice::ObjectPrx",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ice::ObjectPrx* object = ((const Ice::ObjectPrx*)  tolua_tousertype(tolua_S,2,0));
  {
   Ice::ObjectPrx* tolua_ret = (Ice::ObjectPrx*)  Mtolua_new((Ice::ObjectPrx)(*object));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ice::ObjectPrx");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ice_getCommunicator of class  Ice::ObjectPrx */
#ifndef TOLUA_DISABLE_tolua_Ice_Ice_ObjectPrx_ice_getCommunicator00
static int tolua_Ice_Ice_ObjectPrx_ice_getCommunicator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ice::ObjectPrx",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ice::ObjectPrx self = *(Ice::ObjectPrx*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ice_getCommunicator'", NULL);
#endif
  {
   Ice::CommunicatorPtr tolua_ret = (Ice::CommunicatorPtr)  self->ice_getCommunicator();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ice::CommunicatorPtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ice::CommunicatorPtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ice::CommunicatorPtr));
     tolua_pushusertype(tolua_S,tolua_obj,"Ice::CommunicatorPtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ice_getCommunicator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: what of class  std::exception */
#ifndef TOLUA_DISABLE_tolua_Ice_std_exception_what00
static int tolua_Ice_std_exception_what00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::exception",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::exception* self = (std::exception*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'what'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->what();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'what'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_Ice__Byte__new00
static int tolua_Ice_std_vector_Ice__Byte__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<Ice::Byte>* tolua_ret = (std::vector<Ice::Byte>*)  Mtolua_new((std::vector<Ice::Byte>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<Ice::Byte>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<Ice::Byte> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_Ice__Byte__new00_local
static int tolua_Ice_std_vector_Ice__Byte__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<Ice::Byte>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<Ice::Byte>* tolua_ret = (std::vector<Ice::Byte>*)  Mtolua_new((std::vector<Ice::Byte>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<Ice::Byte>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<bool> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_bool__new00
static int tolua_Ice_std_vector_bool__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<bool>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<bool>* tolua_ret = (std::vector<bool>*)  Mtolua_new((std::vector<bool>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<bool>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<bool> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_bool__new00_local
static int tolua_Ice_std_vector_bool__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<bool>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<bool>* tolua_ret = (std::vector<bool>*)  Mtolua_new((std::vector<bool>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<bool>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<char> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_char__new00
static int tolua_Ice_std_vector_char__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<char>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<char>* tolua_ret = (std::vector<char>*)  Mtolua_new((std::vector<char>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<char>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<char> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_char__new00_local
static int tolua_Ice_std_vector_char__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<char>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<char>* tolua_ret = (std::vector<char>*)  Mtolua_new((std::vector<char>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<char>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<short> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_short__new00
static int tolua_Ice_std_vector_short__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<short>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<short>* tolua_ret = (std::vector<short>*)  Mtolua_new((std::vector<short>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<short>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<short> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_short__new00_local
static int tolua_Ice_std_vector_short__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<short>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<short>* tolua_ret = (std::vector<short>*)  Mtolua_new((std::vector<short>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<short>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_int__new00
static int tolua_Ice_std_vector_int__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<int>* tolua_ret = (std::vector<int>*)  Mtolua_new((std::vector<int>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<int>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<int> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_int__new00_local
static int tolua_Ice_std_vector_int__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<int>* tolua_ret = (std::vector<int>*)  Mtolua_new((std::vector<int>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<long> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_long__new00
static int tolua_Ice_std_vector_long__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<long>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<long>* tolua_ret = (std::vector<long>*)  Mtolua_new((std::vector<long>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<long>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<long> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_long__new00_local
static int tolua_Ice_std_vector_long__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<long>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<long>* tolua_ret = (std::vector<long>*)  Mtolua_new((std::vector<long>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<long>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<double> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_double__new00
static int tolua_Ice_std_vector_double__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<double>* tolua_ret = (std::vector<double>*)  Mtolua_new((std::vector<double>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<double>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<double> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_double__new00_local
static int tolua_Ice_std_vector_double__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<double>* tolua_ret = (std::vector<double>*)  Mtolua_new((std::vector<double>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<float> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_float__new00
static int tolua_Ice_std_vector_float__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<float>* tolua_ret = (std::vector<float>*)  Mtolua_new((std::vector<float>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<float>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<float> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_float__new00_local
static int tolua_Ice_std_vector_float__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<float>* tolua_ret = (std::vector<float>*)  Mtolua_new((std::vector<float>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_std__string__new00
static int tolua_Ice_std_vector_std__string__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<std::string>* tolua_ret = (std::vector<std::string>*)  Mtolua_new((std::vector<std::string>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<std::string>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_Ice_std_vector_std__string__new00_local
static int tolua_Ice_std_vector_std__string__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<std::string>* tolua_ret = (std::vector<std::string>*)  Mtolua_new((std::vector<std::string>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: registerException of class  LuaException */
#ifndef TOLUA_DISABLE_tolua_Ice_LuaException_registerException00
static int tolua_Ice_LuaException_registerException00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"LuaException",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::string exceptionName = ((std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   LuaException::registerException(exceptionName);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'registerException'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ice_name of class  LuaException */
#ifndef TOLUA_DISABLE_tolua_Ice_LuaException_ice_name00
static int tolua_Ice_LuaException_ice_name00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaException",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaException* self = (LuaException*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ice_name'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->ice_name();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ice_name'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getStream of class  LuaException */
#ifndef TOLUA_DISABLE_tolua_Ice_LuaException_getStream00
static int tolua_Ice_LuaException_getStream00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaException",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaException* self = (LuaException*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getStream'", NULL);
#endif
  {
   InputStreamWrapper* tolua_ret = (InputStreamWrapper*)  self->getStream();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"InputStreamWrapper");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getStream'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readBool of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readBool00
static int tolua_Ice_InputStreamWrapper_readBool00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readBool'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->readBool();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readBool'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readByte of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readByte00
static int tolua_Ice_InputStreamWrapper_readByte00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readByte'", NULL);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->readByte();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readByte'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readShort of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readShort00
static int tolua_Ice_InputStreamWrapper_readShort00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readShort'", NULL);
#endif
  {
    short tolua_ret = (  short)  self->readShort();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readShort'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readInt of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readInt00
static int tolua_Ice_InputStreamWrapper_readInt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readInt'", NULL);
#endif
  {
    int tolua_ret = (  int)  self->readInt();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readInt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readLong of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readLong00
static int tolua_Ice_InputStreamWrapper_readLong00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readLong'", NULL);
#endif
  {
   Ice::Long tolua_ret = (Ice::Long)  self->readLong();
   toluafix_push_longlong(tolua_S, &tolua_ret,"Ice::Long");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readLong'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readFloat of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readFloat00
static int tolua_Ice_InputStreamWrapper_readFloat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readFloat'", NULL);
#endif
  {
    float tolua_ret = (  float)  self->readFloat();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readFloat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readDouble of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readDouble00
static int tolua_Ice_InputStreamWrapper_readDouble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readDouble'", NULL);
#endif
  {
    double tolua_ret = (  double)  self->readDouble();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readDouble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readString of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readString00
static int tolua_Ice_InputStreamWrapper_readString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  bool b = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readString'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->readString(b);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readProxy of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readProxy00
static int tolua_Ice_InputStreamWrapper_readProxy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readProxy'", NULL);
#endif
  {
   Ice::ObjectPrx tolua_ret = (Ice::ObjectPrx)  self->readProxy();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ice::ObjectPrx)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ice::ObjectPrx");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ice::ObjectPrx));
     tolua_pushusertype(tolua_S,tolua_obj,"Ice::ObjectPrx");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readProxy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readIntSeq of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readIntSeq00
static int tolua_Ice_InputStreamWrapper_readIntSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readIntSeq'", NULL);
#endif
  {
   vector<int> tolua_ret = (vector<int>)  self->readIntSeq();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((vector<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"vector<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"vector<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readIntSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readStringSeq of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readStringSeq00
static int tolua_Ice_InputStreamWrapper_readStringSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readStringSeq'", NULL);
#endif
  {
   vector<string> tolua_ret = (vector<string>)  self->readStringSeq();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((vector<string>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"vector<string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<string>));
     tolua_pushusertype(tolua_S,tolua_obj,"vector<string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readStringSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readLongSeq of class  InputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_InputStreamWrapper_readLongSeq00
static int tolua_Ice_InputStreamWrapper_readLongSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"InputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  InputStreamWrapper* self = (InputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readLongSeq'", NULL);
#endif
  {
   vector<Ice::Long> tolua_ret = (vector<Ice::Long>)  self->readLongSeq();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((vector<Ice::Long>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"vector<Ice::Long>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<Ice::Long>));
     tolua_pushusertype(tolua_S,tolua_obj,"vector<Ice::Long>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'readLongSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_delete00
static int tolua_Ice_OutputStreamWrapper_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeBool of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeBool00
static int tolua_Ice_OutputStreamWrapper_writeBool00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  bool tolua_var_4 = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeBool'", NULL);
#endif
  {
   self->writeBool(tolua_var_4);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeBool'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeByte of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeByte00
static int tolua_Ice_OutputStreamWrapper_writeByte00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  unsigned char tolua_var_5 = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeByte'", NULL);
#endif
  {
   self->writeByte(tolua_var_5);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeByte'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeShort of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeShort00
static int tolua_Ice_OutputStreamWrapper_writeShort00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
   short tolua_var_6 = ((  short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeShort'", NULL);
#endif
  {
   self->writeShort(tolua_var_6);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeShort'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeInt of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeInt00
static int tolua_Ice_OutputStreamWrapper_writeInt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
   int tolua_var_7 = ((  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeInt'", NULL);
#endif
  {
   self->writeInt(tolua_var_7);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeInt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeLong of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeLong00
static int tolua_Ice_OutputStreamWrapper_writeLong00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !toluafix_is_longlong(tolua_S,2,"Ice::Long",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  Ice::Long tolua_var_8 = (toluafix_to_longlong(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeLong'", NULL);
#endif
  {
   self->writeLong(tolua_var_8);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeLong'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeFloat of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeFloat00
static int tolua_Ice_OutputStreamWrapper_writeFloat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
   float tolua_var_9 = ((  float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeFloat'", NULL);
#endif
  {
   self->writeFloat(tolua_var_9);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeFloat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeDouble of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeDouble00
static int tolua_Ice_OutputStreamWrapper_writeDouble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
   double tolua_var_10 = ((  double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeDouble'", NULL);
#endif
  {
   self->writeDouble(tolua_var_10);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeDouble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeString of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeString00
static int tolua_Ice_OutputStreamWrapper_writeString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  std::string tolua_var_11 = ((std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeString'", NULL);
#endif
  {
   self->writeString(tolua_var_11);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeBoolSeq of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeBoolSeq00
static int tolua_Ice_OutputStreamWrapper_writeBoolSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<bool>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  vector<bool> tolua_var_12 = *((vector<bool>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeBoolSeq'", NULL);
#endif
  {
   self->writeBoolSeq(tolua_var_12);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeBoolSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeByteSeq of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeByteSeq00
static int tolua_Ice_OutputStreamWrapper_writeByteSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<Ice::Byte>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  vector<Ice::Byte> tolua_var_13 = *((vector<Ice::Byte>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeByteSeq'", NULL);
#endif
  {
   self->writeByteSeq(tolua_var_13);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeByteSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeShortSeq of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeShortSeq00
static int tolua_Ice_OutputStreamWrapper_writeShortSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<Ice::Short>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  vector<Ice::Short> tolua_var_14 = *((vector<Ice::Short>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeShortSeq'", NULL);
#endif
  {
   self->writeShortSeq(tolua_var_14);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeShortSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeIntSeq of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeIntSeq00
static int tolua_Ice_OutputStreamWrapper_writeIntSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  vector<int> tolua_var_15 = *((vector<int>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeIntSeq'", NULL);
#endif
  {
   self->writeIntSeq(tolua_var_15);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeIntSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeLongSeq of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeLongSeq00
static int tolua_Ice_OutputStreamWrapper_writeLongSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<Ice::Long>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  vector<Ice::Long> tolua_var_16 = *((vector<Ice::Long>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeLongSeq'", NULL);
#endif
  {
   self->writeLongSeq(tolua_var_16);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeLongSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeFloatSeq of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeFloatSeq00
static int tolua_Ice_OutputStreamWrapper_writeFloatSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<Ice::Float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  vector<Ice::Float> tolua_var_17 = *((vector<Ice::Float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeFloatSeq'", NULL);
#endif
  {
   self->writeFloatSeq(tolua_var_17);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeFloatSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeDoubleSeq of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeDoubleSeq00
static int tolua_Ice_OutputStreamWrapper_writeDoubleSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<Ice::Double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  vector<Ice::Double> tolua_var_18 = *((vector<Ice::Double>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeDoubleSeq'", NULL);
#endif
  {
   self->writeDoubleSeq(tolua_var_18);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeDoubleSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeStringSeq of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeStringSeq00
static int tolua_Ice_OutputStreamWrapper_writeStringSeq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<std::string>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  vector<std::string> tolua_var_19 = *((vector<std::string>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeStringSeq'", NULL);
#endif
  {
   self->writeStringSeq(tolua_var_19);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeStringSeq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeProxy of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_writeProxy00
static int tolua_Ice_OutputStreamWrapper_writeProxy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ice::ObjectPrx",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
  const Ice::ObjectPrx* v = ((const Ice::ObjectPrx*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeProxy'", NULL);
#endif
  {
   self->writeProxy(*v);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeProxy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getData of class  OutputStreamWrapper */
#ifndef TOLUA_DISABLE_tolua_Ice_OutputStreamWrapper_getData00
static int tolua_Ice_OutputStreamWrapper_getData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"OutputStreamWrapper",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  OutputStreamWrapper* self = (OutputStreamWrapper*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getData'", NULL);
#endif
  {
   std::vector<Ice::Byte>* tolua_ret = (std::vector<Ice::Byte>*)  self->getData();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<Ice::Byte>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_Ice_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  tolua_module(tolua_S,"Ice",0);
  tolua_beginmodule(tolua_S,"Ice");
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"vector_int_","vector<int>","",tolua_collect_vector_int_);
  #else
  tolua_cclass(tolua_S,"vector_int_","vector<int>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"vector_int_");
   tolua_function(tolua_S,"clear",tolua_Ice_vector_int__clear00);
   tolua_function(tolua_S,"size",tolua_Ice_vector_int__size00);
   tolua_function(tolua_S,".geti",tolua_Ice_vector_int___geti00);
   tolua_function(tolua_S,".seti",tolua_Ice_vector_int___seti00);
   tolua_function(tolua_S,".geti",tolua_Ice_vector_int___geti01);
   tolua_function(tolua_S,"push_back",tolua_Ice_vector_int__push_back00);
   tolua_function(tolua_S,"new",tolua_Ice_vector_int__new00);
   tolua_function(tolua_S,"new_local",tolua_Ice_vector_int__new00_local);
   tolua_function(tolua_S,".call",tolua_Ice_vector_int__new00_local);
   tolua_function(tolua_S,"delete",tolua_Ice_vector_int__delete00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"vector_string_","vector<string>","",tolua_collect_vector_string_);
  #else
  tolua_cclass(tolua_S,"vector_string_","vector<string>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"vector_string_");
   tolua_function(tolua_S,"clear",tolua_Ice_vector_string__clear00);
   tolua_function(tolua_S,"size",tolua_Ice_vector_string__size00);
   tolua_function(tolua_S,".geti",tolua_Ice_vector_string___geti00);
   tolua_function(tolua_S,".seti",tolua_Ice_vector_string___seti00);
   tolua_function(tolua_S,".geti",tolua_Ice_vector_string___geti01);
   tolua_function(tolua_S,"push_back",tolua_Ice_vector_string__push_back00);
   tolua_function(tolua_S,"new",tolua_Ice_vector_string__new00);
   tolua_function(tolua_S,"new_local",tolua_Ice_vector_string__new00_local);
   tolua_function(tolua_S,".call",tolua_Ice_vector_string__new00_local);
   tolua_function(tolua_S,"delete",tolua_Ice_vector_string__delete00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"vector_Ice__Long_","vector<Ice::Long>","",tolua_collect_vector_Ice__Long_);
  #else
  tolua_cclass(tolua_S,"vector_Ice__Long_","vector<Ice::Long>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"vector_Ice__Long_");
   tolua_function(tolua_S,"clear",tolua_Ice_vector_Ice__Long__clear00);
   tolua_function(tolua_S,"size",tolua_Ice_vector_Ice__Long__size00);
   tolua_function(tolua_S,".geti",tolua_Ice_vector_Ice__Long___geti00);
   tolua_function(tolua_S,".seti",tolua_Ice_vector_Ice__Long___seti00);
   tolua_function(tolua_S,".geti",tolua_Ice_vector_Ice__Long___geti01);
   tolua_function(tolua_S,"push_back",tolua_Ice_vector_Ice__Long__push_back00);
   tolua_function(tolua_S,"new",tolua_Ice_vector_Ice__Long__new00);
   tolua_function(tolua_S,"new_local",tolua_Ice_vector_Ice__Long__new00_local);
   tolua_function(tolua_S,".call",tolua_Ice_vector_Ice__Long__new00_local);
   tolua_function(tolua_S,"delete",tolua_Ice_vector_Ice__Long__delete00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"vector_Ice__Byte_","vector<Ice::Byte>","",tolua_collect_vector_Ice__Byte_);
  #else
  tolua_cclass(tolua_S,"vector_Ice__Byte_","vector<Ice::Byte>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"vector_Ice__Byte_");
   tolua_function(tolua_S,"clear",tolua_Ice_vector_Ice__Byte__clear00);
   tolua_function(tolua_S,"size",tolua_Ice_vector_Ice__Byte__size00);
   tolua_function(tolua_S,".geti",tolua_Ice_vector_Ice__Byte___geti00);
   tolua_function(tolua_S,".seti",tolua_Ice_vector_Ice__Byte___seti00);
   tolua_function(tolua_S,".geti",tolua_Ice_vector_Ice__Byte___geti01);
   tolua_function(tolua_S,"push_back",tolua_Ice_vector_Ice__Byte__push_back00);
   tolua_function(tolua_S,"new",tolua_Ice_vector_Ice__Byte__new00);
   tolua_function(tolua_S,"new_local",tolua_Ice_vector_Ice__Byte__new00_local);
   tolua_function(tolua_S,".call",tolua_Ice_vector_Ice__Byte__new00_local);
   tolua_function(tolua_S,"delete",tolua_Ice_vector_Ice__Byte__delete00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"map_int_int_","map<int,int>","",NULL);
  tolua_beginmodule(tolua_S,"map_int_int_");
   tolua_function(tolua_S,"size",tolua_Ice_map_int_int__size00);
   tolua_function(tolua_S,".seti",tolua_Ice_map_int_int___seti00);
   tolua_function(tolua_S,".geti",tolua_Ice_map_int_int___geti00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"LuaDelegate","LuaDelegate","",NULL);
  tolua_beginmodule(tolua_S,"LuaDelegate");
   tolua_function(tolua_S,"addScriptHandler",tolua_Ice_LuaDelegate_addScriptHandler00);
   tolua_function(tolua_S,"removeScriptHandler",tolua_Ice_LuaDelegate_removeScriptHandler00);
   tolua_function(tolua_S,"clearScriptHandler",tolua_Ice_LuaDelegate_clearScriptHandler00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ConnectionInfo","ConnectionInfo","",tolua_collect_ConnectionInfo);
  #else
  tolua_cclass(tolua_S,"ConnectionInfo","ConnectionInfo","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ConnectionInfo");
   tolua_function(tolua_S,"new",tolua_Ice_ConnectionInfo_new00);
   tolua_function(tolua_S,"new_local",tolua_Ice_ConnectionInfo_new00_local);
   tolua_function(tolua_S,".call",tolua_Ice_ConnectionInfo_new00_local);
   tolua_function(tolua_S,"new",tolua_Ice_ConnectionInfo_new01);
   tolua_function(tolua_S,"new_local",tolua_Ice_ConnectionInfo_new01_local);
   tolua_function(tolua_S,".call",tolua_Ice_ConnectionInfo_new01_local);
   tolua_function(tolua_S,"setProperty",tolua_Ice_ConnectionInfo_setProperty00);
   tolua_variable(tolua_S,"account",tolua_get_ConnectionInfo_account,tolua_set_ConnectionInfo_account);
   tolua_variable(tolua_S,"password",tolua_get_ConnectionInfo_password,tolua_set_ConnectionInfo_password);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CCIceSession","CCIceSession","",tolua_collect_CCIceSession);
  #else
  tolua_cclass(tolua_S,"CCIceSession","CCIceSession","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CCIceSession");
   tolua_function(tolua_S,"delete",tolua_Ice_CCIceSession_delete00);
   tolua_function(tolua_S,"connect",tolua_Ice_CCIceSession_connect00);
   tolua_function(tolua_S,"disconnect",tolua_Ice_CCIceSession_disconnect00);
   tolua_function(tolua_S,"invoke",tolua_Ice_CCIceSession_invoke00);
   tolua_function(tolua_S,"addCallback",tolua_Ice_CCIceSession_addCallback00);
   tolua_function(tolua_S,"createOutputStream",tolua_Ice_CCIceSession_createOutputStream00);
   tolua_function(tolua_S,"disconnect",tolua_Ice_CCIceSession_disconnect01);
   tolua_function(tolua_S,"create",tolua_Ice_CCIceSession_create00);
   tolua_variable(tolua_S,"eventConnected",tolua_get_CCIceSession_eventConnected,NULL);
   tolua_variable(tolua_S,"eventConnectFailed",tolua_get_CCIceSession_eventConnectFailed,NULL);
   tolua_variable(tolua_S,"eventDisconnected",tolua_get_CCIceSession_eventDisconnected,NULL);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Glacier2",0);
  tolua_beginmodule(tolua_S,"Glacier2");
   tolua_cclass(tolua_S,"SessionPrx","Glacier2::SessionPrx","",NULL);
   tolua_beginmodule(tolua_S,"SessionPrx");
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ice",0);
  tolua_beginmodule(tolua_S,"Ice");
   tolua_cclass(tolua_S,"Exception","Ice::Exception","",NULL);
   tolua_beginmodule(tolua_S,"Exception");
    tolua_function(tolua_S,"what",tolua_Ice_Ice_Exception_what00);
    tolua_function(tolua_S,"ice_name",tolua_Ice_Ice_Exception_ice_name00);
   tolua_endmodule(tolua_S);
   tolua_constant(tolua_S,"Normal",Ice::Normal);
   tolua_constant(tolua_S,"Nonmutating",Ice::Nonmutating);
   tolua_constant(tolua_S,"Idempotent",Ice::Idempotent);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"ObjectPrx","Ice::ObjectPrx","",tolua_collect_Ice__ObjectPrx);
   #else
   tolua_cclass(tolua_S,"ObjectPrx","Ice::ObjectPrx","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"ObjectPrx");
    tolua_function(tolua_S,"new",tolua_Ice_Ice_ObjectPrx_new00);
    tolua_function(tolua_S,"new_local",tolua_Ice_Ice_ObjectPrx_new00_local);
    tolua_function(tolua_S,".call",tolua_Ice_Ice_ObjectPrx_new00_local);
    tolua_function(tolua_S,"ice_getCommunicator",tolua_Ice_Ice_ObjectPrx_ice_getCommunicator00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"std",0);
  tolua_beginmodule(tolua_S,"std");
   tolua_cclass(tolua_S,"exception","std::exception","",NULL);
   tolua_beginmodule(tolua_S,"exception");
    tolua_function(tolua_S,"what",tolua_Ice_std_exception_what00);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_Ice__Byte_","std::vector<Ice::Byte>","",tolua_collect_std__vector_Ice__Byte_);
   #else
   tolua_cclass(tolua_S,"vector_Ice__Byte_","std::vector<Ice::Byte>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_Ice__Byte_");
    tolua_function(tolua_S,"new",tolua_Ice_std_vector_Ice__Byte__new00);
    tolua_function(tolua_S,"new_local",tolua_Ice_std_vector_Ice__Byte__new00_local);
    tolua_function(tolua_S,".call",tolua_Ice_std_vector_Ice__Byte__new00_local);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_bool_","std::vector<bool>","",tolua_collect_std__vector_bool_);
   #else
   tolua_cclass(tolua_S,"vector_bool_","std::vector<bool>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_bool_");
    tolua_function(tolua_S,"new",tolua_Ice_std_vector_bool__new00);
    tolua_function(tolua_S,"new_local",tolua_Ice_std_vector_bool__new00_local);
    tolua_function(tolua_S,".call",tolua_Ice_std_vector_bool__new00_local);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_char_","std::vector<char>","",tolua_collect_std__vector_char_);
   #else
   tolua_cclass(tolua_S,"vector_char_","std::vector<char>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_char_");
    tolua_function(tolua_S,"new",tolua_Ice_std_vector_char__new00);
    tolua_function(tolua_S,"new_local",tolua_Ice_std_vector_char__new00_local);
    tolua_function(tolua_S,".call",tolua_Ice_std_vector_char__new00_local);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_short_","std::vector<short>","",tolua_collect_std__vector_short_);
   #else
   tolua_cclass(tolua_S,"vector_short_","std::vector<short>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_short_");
    tolua_function(tolua_S,"new",tolua_Ice_std_vector_short__new00);
    tolua_function(tolua_S,"new_local",tolua_Ice_std_vector_short__new00_local);
    tolua_function(tolua_S,".call",tolua_Ice_std_vector_short__new00_local);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_int_","std::vector<int>","",tolua_collect_std__vector_int_);
   #else
   tolua_cclass(tolua_S,"vector_int_","std::vector<int>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_int_");
    tolua_function(tolua_S,"new",tolua_Ice_std_vector_int__new00);
    tolua_function(tolua_S,"new_local",tolua_Ice_std_vector_int__new00_local);
    tolua_function(tolua_S,".call",tolua_Ice_std_vector_int__new00_local);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_long_","std::vector<long>","",tolua_collect_std__vector_long_);
   #else
   tolua_cclass(tolua_S,"vector_long_","std::vector<long>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_long_");
    tolua_function(tolua_S,"new",tolua_Ice_std_vector_long__new00);
    tolua_function(tolua_S,"new_local",tolua_Ice_std_vector_long__new00_local);
    tolua_function(tolua_S,".call",tolua_Ice_std_vector_long__new00_local);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_double_","std::vector<double>","",tolua_collect_std__vector_double_);
   #else
   tolua_cclass(tolua_S,"vector_double_","std::vector<double>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_double_");
    tolua_function(tolua_S,"new",tolua_Ice_std_vector_double__new00);
    tolua_function(tolua_S,"new_local",tolua_Ice_std_vector_double__new00_local);
    tolua_function(tolua_S,".call",tolua_Ice_std_vector_double__new00_local);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_float_","std::vector<float>","",tolua_collect_std__vector_float_);
   #else
   tolua_cclass(tolua_S,"vector_float_","std::vector<float>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_float_");
    tolua_function(tolua_S,"new",tolua_Ice_std_vector_float__new00);
    tolua_function(tolua_S,"new_local",tolua_Ice_std_vector_float__new00_local);
    tolua_function(tolua_S,".call",tolua_Ice_std_vector_float__new00_local);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_std__string_","std::vector<std::string>","",tolua_collect_std__vector_std__string_);
   #else
   tolua_cclass(tolua_S,"vector_std__string_","std::vector<std::string>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_std__string_");
    tolua_function(tolua_S,"new",tolua_Ice_std_vector_std__string__new00);
    tolua_function(tolua_S,"new_local",tolua_Ice_std_vector_std__string__new00_local);
    tolua_function(tolua_S,".call",tolua_Ice_std_vector_std__string__new00_local);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"LuaException","LuaException","Ice::Exception",NULL);
  tolua_beginmodule(tolua_S,"LuaException");
   tolua_function(tolua_S,"registerException",tolua_Ice_LuaException_registerException00);
   tolua_function(tolua_S,"ice_name",tolua_Ice_LuaException_ice_name00);
   tolua_function(tolua_S,"getStream",tolua_Ice_LuaException_getStream00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"InputStreamWrapper","InputStreamWrapper","",NULL);
  tolua_beginmodule(tolua_S,"InputStreamWrapper");
   tolua_function(tolua_S,"readBool",tolua_Ice_InputStreamWrapper_readBool00);
   tolua_function(tolua_S,"readByte",tolua_Ice_InputStreamWrapper_readByte00);
   tolua_function(tolua_S,"readShort",tolua_Ice_InputStreamWrapper_readShort00);
   tolua_function(tolua_S,"readInt",tolua_Ice_InputStreamWrapper_readInt00);
   tolua_function(tolua_S,"readLong",tolua_Ice_InputStreamWrapper_readLong00);
   tolua_function(tolua_S,"readFloat",tolua_Ice_InputStreamWrapper_readFloat00);
   tolua_function(tolua_S,"readDouble",tolua_Ice_InputStreamWrapper_readDouble00);
   tolua_function(tolua_S,"readString",tolua_Ice_InputStreamWrapper_readString00);
   tolua_function(tolua_S,"readProxy",tolua_Ice_InputStreamWrapper_readProxy00);
   tolua_function(tolua_S,"readIntSeq",tolua_Ice_InputStreamWrapper_readIntSeq00);
   tolua_function(tolua_S,"readStringSeq",tolua_Ice_InputStreamWrapper_readStringSeq00);
   tolua_function(tolua_S,"readLongSeq",tolua_Ice_InputStreamWrapper_readLongSeq00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"OutputStreamWrapper","OutputStreamWrapper","",tolua_collect_OutputStreamWrapper);
  #else
  tolua_cclass(tolua_S,"OutputStreamWrapper","OutputStreamWrapper","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"OutputStreamWrapper");
   tolua_function(tolua_S,"delete",tolua_Ice_OutputStreamWrapper_delete00);
   tolua_function(tolua_S,"writeBool",tolua_Ice_OutputStreamWrapper_writeBool00);
   tolua_function(tolua_S,"writeByte",tolua_Ice_OutputStreamWrapper_writeByte00);
   tolua_function(tolua_S,"writeShort",tolua_Ice_OutputStreamWrapper_writeShort00);
   tolua_function(tolua_S,"writeInt",tolua_Ice_OutputStreamWrapper_writeInt00);
   tolua_function(tolua_S,"writeLong",tolua_Ice_OutputStreamWrapper_writeLong00);
   tolua_function(tolua_S,"writeFloat",tolua_Ice_OutputStreamWrapper_writeFloat00);
   tolua_function(tolua_S,"writeDouble",tolua_Ice_OutputStreamWrapper_writeDouble00);
   tolua_function(tolua_S,"writeString",tolua_Ice_OutputStreamWrapper_writeString00);
   tolua_function(tolua_S,"writeBoolSeq",tolua_Ice_OutputStreamWrapper_writeBoolSeq00);
   tolua_function(tolua_S,"writeByteSeq",tolua_Ice_OutputStreamWrapper_writeByteSeq00);
   tolua_function(tolua_S,"writeShortSeq",tolua_Ice_OutputStreamWrapper_writeShortSeq00);
   tolua_function(tolua_S,"writeIntSeq",tolua_Ice_OutputStreamWrapper_writeIntSeq00);
   tolua_function(tolua_S,"writeLongSeq",tolua_Ice_OutputStreamWrapper_writeLongSeq00);
   tolua_function(tolua_S,"writeFloatSeq",tolua_Ice_OutputStreamWrapper_writeFloatSeq00);
   tolua_function(tolua_S,"writeDoubleSeq",tolua_Ice_OutputStreamWrapper_writeDoubleSeq00);
   tolua_function(tolua_S,"writeStringSeq",tolua_Ice_OutputStreamWrapper_writeStringSeq00);
   tolua_function(tolua_S,"writeProxy",tolua_Ice_OutputStreamWrapper_writeProxy00);
   tolua_function(tolua_S,"getData",tolua_Ice_OutputStreamWrapper_getData00);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_Ice (lua_State* tolua_S) {
 return tolua_Ice_open(tolua_S);
};
#endif

